home *** CD-ROM | disk | FTP | other *** search
/ Ham Radio 2000 #2 / Ham Radio 2000 - Volume 2.iso / HAMV2 / TCP_IP / TNOS230S / BUCKBOOK.C < prev    next >
Encoding:
C/C++ Source or Header  |  1997-08-18  |  36.1 KB  |  1,205 lines
  1. #ifdef MSDOS
  2. #include "global.h"
  3. #ifndef QRZCALLB
  4. #if defined CALLSERVER || defined ICALL || defined CALLCLI
  5. #include "ctype.h"
  6. #include <time.h>
  7. #include <fcntl.h>
  8. #include <sys/timeb.h>
  9. #include <dos.h>
  10. #include <io.h>
  11. #include "files.h"
  12. #include "socket.h"
  13. #include "cmdparse.h"
  14. #include "ftp.h"
  15.  
  16. #if !defined(_lint)
  17. static char rcsid[] OPTIONAL = "$Id: buckbook.c,v 1.14 1997/08/19 01:19:22 root Exp root $";
  18. #endif
  19.  
  20. /*
  21.     Fred Peachman KB7YW
  22.     7186 Northview Drive
  23.     Brookfield, OH 44403
  24.  
  25.     Fri  05-08-1992
  26.     OK here is my "final" product for the Buckmaster "HamCall" CD-ROM based
  27.     callsign server.
  28.  
  29.    It is a substitute for N4PCR's callsign server. The intent is to replace
  30.    N4PCR's callbook.c with this file - and have a callsign server that will
  31.    run off Buckmaster's CD-ROM: the October 1991 "HAM CALL" CD.(or May  '92)
  32.  
  33.    The CD-ROM must be configured with a driver installed in config.sys,
  34.    and the mscdex.exe TSR must be running.
  35.  
  36.    This module can be compiled one of two ways.
  37.  
  38.     In config.h:
  39.  
  40.    - If CALLSERVER is defined, but ICALL is not:
  41.       you get the same sort of callsign server that I did for the
  42.       October '91 Ham Call CD. It is compatible with either the October
  43.       '91 CD or the May '92 CD. The October '91 CD can utilize the
  44.       Canadian Callsign database as well as the U.S. The May '92 CD does
  45.       not provide the separate Canadian callsign database so the
  46.       "callserver database canadian" command should not be used in
  47.       autoexec.nos. One new feature to this old server is provision for
  48.       "cross-referencing", a feature that is new with May '92 HamCall CD
  49.       but not on the October '91 CD.
  50.  
  51.    - If ICALL is defined, you get the international callsign database
  52.       that is new for the May '92 HamCall CD. The international callsign
  53.       database contains U.S., Canadian and a smattering of foreign callsigns.
  54.       It is based on shelling out to Buckmaster's icall.exe utility which
  55.       is located in the root directory of the May '92 CD. THIS option is
  56.       NOT available on the October '91 HamCall CD!!
  57.  
  58.         To set it up, you use the "cdrom" command to tell NOS the drive
  59.       letter of your CD-ROM drive. You set yourself up as the callserver
  60.       with "callserver hostname <hostname>". You "start callbook". That's it!
  61.  
  62.       - de KB7YW
  63.  
  64.    ---------------------------------------------------------------------------
  65.    - for CALLSERVER:
  66.    Wed  04-29-1992 Mods for the May '92 callbook server. Buckmaster does
  67.    not provide a separate Canadian callsign database on this CD. So this
  68.    code will only be good for the USA database: "s:\\ham0\\hamcall.129".
  69.    "Cross-referencing" works: For a callsign which has changed, the old
  70.    call will be displayed, the date it was changed will be given, and the
  71.    amateur's directory listing under his new callsign will be given. As
  72.    for ICALL, since this is a simple shell to Buckmaster's icall.exe
  73.    utility, I cannot add cross-referencing!
  74.  
  75.    The callserver database commands will configure the cd-rom.
  76.  
  77.    config.h must #define CALLCLI or CALLSERVER. If CALLSERVER is #define'd
  78.    CALLCLI is forced on by config.h. Only CALLCLI can be #define'd separately
  79.    of CALLSERVER so it is the default condition for compilation of this
  80.    module - which won't used at all if neither CALLCLI nor CALLSERVER are
  81.    #define'd in config.h.
  82.  */
  83.  
  84. /* if ICALL is defined, it forces CALLSERVER to be defined. However, if
  85.   CALLSERVER is defined, it does not force ICALL. Therefore definition of
  86.   ICALL controls which server code gets compiled.
  87.  
  88.   If neither CALLSERVER nor ICALL is defined, this module might still be
  89.   needed if CALLCLI is defined, for the callserver client code.
  90.  
  91.  */
  92. #if defined(ICALL) && !defined(CALLSERVER)
  93. #define CALLSERVER 1
  94. #endif    /* #ifdef ICALL */
  95.  
  96. struct months {
  97.     char *m;  /* name of month  */
  98.     int  d;   /* days in month  */
  99. };
  100.  
  101. char  *Callserver = NULLCHAR;
  102.  
  103. int docallserver(int argc,char *argv[],void *p);
  104.  
  105. static int
  106. docallserver_hostname(int argc,char *argv[],void *p);
  107.  
  108.  
  109. #ifdef CALLSERVER
  110. static int
  111. docallserver_databases(int argc,char *argv[],void *p);
  112.  
  113. /* CD-ROM code by Fred Peachman KB7YW */
  114. char *CDROM = NULLCHAR;
  115. char *cdrom_prompt =
  116. "\tUse the \"cdrom\" command to specify CD-ROM's drive letter\n";
  117. struct months month[12] = {
  118.     {"January", 31},{"February",28},{"March",31},{"April",30},{"May",31},
  119.     {"June",30},{"July",31},{"August",31},{"September",30},{"October",31},
  120.     {"November",30},{"December",31}
  121. };
  122.  
  123. #ifndef ICALL
  124. /* What follows is the original stuff for the Oct '91 Ham Call CD:  */
  125.  
  126. /*struct database_activity
  127.   One of these structs gets filled out by init -
  128.   initializes data base for calls from hamcall.c -
  129.   should be able to handle generic functions across different data base
  130.   formats.
  131.  */
  132. struct database_activity {
  133.     int type;                     /* for checking data/function formats*/
  134. #define USA 0
  135. #define CANADA 1
  136.     int  handle;                  /* -1 if unitialized  */
  137.     unsigned long record;         /* current record #                 */
  138.     void *record_buf;           /* where to read the record to      */
  139. };
  140.  
  141. /* The Buckmaster HAM CALL CD format for U.S. Callsign database       */
  142. struct usa  {
  143.     char callsign[6];   /* None of these fields are ASCIIZ so be careful */
  144.     char lastname[24];
  145.     char firstname[11];
  146.     char middle[1];
  147.     char street[35];
  148.     char city[20];
  149.     char state[2];
  150.     char zip[5];
  151.     char fluff[8];      /* supreme nothingness                            */
  152.     char exp[2];        /* 'X3' if license expired                        */
  153.     char born[2];       /* Last two digits of year of birth  i.e. '54     */
  154.     char expiryr[2];    /* Last two digits of year of license expiration  */
  155.     char expirday[3];   /* The day of the year that license expires       */
  156.     char validyr[2];    /* year that license was issued                   */
  157.     char validday[3];   /* day of the year that license was issued        */
  158.     char class[1];      /* 1 letter license classification                */
  159.     char endline[2];    /* file marker                                    */
  160. };
  161.  
  162. /* The Buckmaster HAM CALL CD format for Canadian Callsign database
  163.    It is 0x9a bytes long (154) The first record has a blank callsign field
  164.    that should be no problem!                                             */
  165.  
  166. struct canada  {
  167.     char callsign[8];
  168.     char name[0xe8 - 0xa2];
  169.     char street[0x10a - 0xe8];
  170.     char town[0x121-0x10a];
  171.     char province[0x12c-0x121];
  172.     char zip[6];
  173.     char endline[2];
  174. };
  175.                     /* generic function calls: headers */
  176. static int
  177. init(struct database_activity *db,int type,int s);
  178. static int
  179. close_down(struct database_activity *db);
  180. static void
  181. disp(char *cfield, int siz, int s);
  182. static int
  183. readrec(struct database_activity *db);
  184. static int
  185. displayrec(struct database_activity *db, int s);
  186. static int
  187. find_call(struct database_activity *db, char *callsign);
  188. static int
  189. make_mask(char *mask, char *callsign, int s);
  190.  
  191.                         /* for u.s.a database:  */
  192. static int
  193. display_usa(void *,int s);
  194. static int
  195. comp_usa_calls(char *, char *);
  196.  
  197.                         /* for canada database  */
  198. static int
  199. display_canada(void *,int s);
  200. static int
  201. comp_canada_calls(char *, char *);
  202.  
  203. /* most of this module is server code, but some is client: CALLCLI is by
  204.    default - forced on in config.h whenever CALLSERVER is #define'd */
  205.  
  206. /* How many different databases are we supporting right now?              */
  207. #define DATABASE_TYPES 2
  208.  
  209. /* how many passes should we make before we give up (in find_call)?    */
  210. #define MAXREADS 30
  211. /*----------------------------------------------------------------------------
  212.  
  213.     Here are arrays of variables to use depending on which database is
  214.     needed. In each array make sure the value order is same as defs for
  215.     database_activity.types i.e. USA, CANADA, ....
  216.  
  217.     In order to tack on another database, add an element for each of these
  218.     arrays, increment the definition for DATABASE_TYPES (above), and
  219.     tell your program how to tell init to use the new one.  In this
  220.     module the launcher (cb_lookup) will figure out which database to
  221.     initialize ("init(type, callsign,s)").
  222.  
  223.     Basically for the new database you would only need to specify its file
  224.     name in database[], write a display function and specify it in
  225.     displayfunc[], specify the size of one record in record_size[],
  226.     write a callsign comparison function and specify it in compare_calls[],
  227.     and specify the byte offset of the callsign field within a record -
  228.     specify this offset in call_offset[] - it will probably be 0 anyway.
  229.  
  230.     You need to write something in cb_lookup to tell init when to initialize
  231.     your new database. Basically if "call" satisfies inspection, initialize
  232.     the appropriate database.
  233.  */
  234.  
  235. char *database[DATABASE_TYPES]  = {
  236.     { NULLCHAR  }, /* "S:\\HAM0\\HAMCALL.129"},  USA  */
  237.     { NULLCHAR  }  /* "S:\\HAM0\\CANADA2.DAT"}   CANADA */
  238. };
  239.  
  240. char *database_label[DATABASE_TYPES]  = {
  241.     { "usa"},{"canadian"}
  242. };
  243.  
  244. int (*displayfunc[DATABASE_TYPES])(void *, int) = {
  245.     { display_usa },
  246.     { display_canada }
  247. };
  248.  
  249. /* basic record size, in bytes, in each database  */
  250. int record_size[DATABASE_TYPES] =   {   129, 154  };
  251.  
  252.             /* How fresh is this stuff in the database?
  253.             Wed  04-29-1992  Now handled by getftime  - KB7YW
  254. static char *Volume = "October 1991";
  255.               */
  256.  
  257.             /* number of records in each type of database */
  258. unsigned long records[DATABASE_TYPES];
  259.  
  260.        /* The database-specific callsign comparison procedure  */
  261. int (*compare_calls[DATABASE_TYPES])(char *,char *) = {
  262.     {comp_usa_calls},{comp_canada_calls}
  263. };
  264. /*      At what offset within a database struct is the callsign located?
  265.                Look at struct usa and struct canada above
  266.  */
  267. int call_offset[DATABASE_TYPES] = { 0,0 };
  268.  
  269. /*
  270. char *BusyServer = "\n\nThe callsign server is busy right now\n\
  271. .... please call back later\n\n";
  272.  */
  273.  
  274. char *Db_Unavail = "\n\nDatabase is not available.\n";
  275.  
  276. char *Db_Not_config = "\n\nDatabase is not configured.\n";
  277.  
  278. static char *TAB = "        ";
  279.  
  280. /*--------------------------------------------------------------------------*/
  281. /* --------------- Generic (database-independent) functions ----------------*/
  282. /*------------------------------------------------------------------------
  283.   Initialize a database activity struct. this consists of making sure
  284.   the database file is opened and that the number of records in that
  285.   file is computed. Also a record_buf is malloced for each db.
  286.  */
  287. static int
  288. init(db, type, s)
  289. struct database_activity *db;
  290. int type;
  291. int s;
  292. {
  293.     long tmp;
  294.     int i;
  295.     extern char *Callserver;  /* declared in calldbd.c  */
  296.     if ((type < 0) || (type >= DATABASE_TYPES))  return -1;
  297.  
  298.     db->type = type;
  299.  
  300.     if (database[type] == NULLCHAR)  {
  301.         usputs(s,Db_Not_config);
  302.         return -1;
  303.     }
  304.  
  305.     i = db->handle = _open(database[type], O_RDONLY | O_BINARY);
  306.     if (i == -1) {
  307.         usputs(s,Db_Unavail);
  308.         return -1;
  309.     }
  310.     for (i = 0; i < 50; i++)  kwait(NULL);
  311.   /* The CD-ROM is a slow device!! - give other processes lots of slack */
  312.  
  313.     tmp = filelength(db->handle);
  314. /*   if (tmp == -1L)  {
  315.     usprintf(s,"Error reading length of file \"%s\"\n\
  316.     please report to the sysop at %s\n",database[type], Callserver);
  317.     return -1;
  318.   }
  319. */
  320.     records[type] = tmp/((long) record_size[type]);
  321.  
  322.     db->record_buf = (char *)mallocw(record_size[type]);
  323.     if (db->record_buf == NULL) {
  324.         usputs(s,Db_Unavail);  /* No memory to allocate, actually  */
  325.         return -1;
  326.     }
  327.     return 0;
  328. }
  329.  
  330. static int
  331. close_down(db)
  332. struct database_activity* db;
  333. {
  334.     free(db->record_buf);
  335.     _close(db->handle);
  336.     return 0;
  337. }
  338. static int
  339. invalid_callsign(callsign, s)
  340. char *callsign;
  341. int s;
  342. {
  343.     usprintf(s,"\n\n\"%s\" is an invalid callsign\n\n", callsign);
  344.     return -1;
  345. }
  346.  
  347. /* make_mask makes a Buckmaster-compatible mask out of the callsign.
  348.   caller must allocate 6 bytes exactly for "mask" or 7 to make an ascii
  349.   string out of it.
  350.  
  351.   callsign is the callsign we are looking to match; mask is the same
  352.   callsign only padded to Left with a space if necessary to keep the
  353.   callsign digit at position 2 (starting with 0), and padded with spaces
  354.   to the right if necessary to make sure the mask is exactly 6 digits
  355.   long.
  356.  
  357.   This routine will work right for US or Canadian callsigns, but NOT with
  358.   foreign callsigns (that contain more than one numeric character) it
  359.   will fail!
  360.  */
  361.  
  362. static int
  363. make_mask(mask, callsign,s)
  364. char *mask;
  365. char *callsign;
  366. int s;
  367. {
  368.     int j, k, len, already=0;
  369.     char *q, *p;
  370.     char tmp[7];
  371.  
  372.     len = (callsign) ? strlen(callsign) : 0;
  373.  
  374.   /* there must be only ONE digit-character at position 1 or 2
  375.       (starting from 0)  */
  376.     q = callsign;
  377.     already = 0;
  378.     for (j = 0; j < len; j++)   {
  379.         if (isdigit(*q++))  {
  380.             if (!(already++)) k = j;/* already counts the number of digit chars */
  381.             else return invalid_callsign(callsign,s);
  382.         }
  383.     }
  384.     if ((k < 1) || ( k > 2))  return invalid_callsign(callsign,s);
  385.  
  386. /* FINALLY, Buckmaster pads to the left with spaces to position the digit at
  387.   mask[2] */
  388.  
  389.     q = mask;
  390.     for (j = 0; j < 6; j++) *q++ = ' '; /* initialize!  */
  391.  
  392.     p = callsign;
  393.     q = mask;
  394.  
  395.     switch (k)  {
  396.         case 1:
  397.             *q++ = ' '; /* left-pad with a space  */
  398.             break;
  399.  
  400.         case 2:
  401.             break;
  402.  
  403.         default:
  404.             break;
  405. /*  usprintf(s,"Error in make_mask %s line %d\n",__FILE__,__LINE__);
  406.     exit(255);
  407. */
  408.     }
  409.  
  410.     for (j = 0; j < len; j++) *q++ = *p++;
  411.  
  412.     return ((int) (mask[2]) &0x0f); /* returns digit of the valid U.S. callsign */
  413. }
  414.  
  415. /* a method for display of non-ASCIIZ strings */
  416. static void
  417. disp(cfield,siz,s)
  418. char *cfield;
  419. int siz;
  420. int s;
  421. {
  422.     char *q;
  423.     int i, sw=0;
  424.  
  425.     q = cfield;
  426.     for (i = 0; i < siz; i++) {
  427. /* Was:
  428.     if ((!sw) || (*q != ' ')) usputc(s, (int) *q, stdout);
  429.     Now is:  (WG7J) */
  430.         if ((!sw) || (*q != ' ')) usputc(s, (int) *q);
  431.         if (*q == ' ') sw = 1;
  432.         else sw = 0;  /* We will print out one space before we quit!  */
  433.         q++;
  434.     }
  435. }
  436. readrec(db)
  437. struct database_activity *db;
  438. {
  439.     off_t filepointer;
  440.     int n;
  441.     int st;
  442.  
  443.     st = db->type;
  444.     filepointer = db->record*((long) record_size[st]);
  445.     lseek(db->handle, filepointer,SEEK_SET);
  446.     n = _read(db->handle, db->record_buf,record_size[st]);
  447.     if (n != -1) return 0;
  448.     else return -1;
  449. }
  450.  
  451. static int
  452. displayrec(db,s)
  453. struct database_activity *db;
  454. int s;
  455. {
  456.     int (*func)(void *v, int s);
  457.  
  458.     func = displayfunc[db->type];
  459. /*   usprintf(s,"\n%s*** Record # % 8lu:***\n",TAB, db->record);  */
  460.     return func(db->record_buf,s);
  461. }
  462. /* find_call: Find the record number that matches the callsign. For any
  463.    callbook data where the records are all of the same length. The
  464.    returned record value is found as db->record.
  465.  
  466.    If the input callsign needs to be converted to a search mask in any
  467.    way, do it then call findcall.
  468.  
  469.    The returned int value is the number of records read during the search
  470.    process.
  471.  */
  472.  
  473. static int
  474. find_call(db, callsign)
  475. struct database_activity *db;
  476. char *callsign;
  477. {
  478.     int i, ret, met= 0, reads = 0;
  479.     long ra,rz;  /* first, middle, last record numbers */
  480.     int (*comp)(char *, char *);
  481.     int st;
  482.     char *rec_call;
  483.  
  484.     st = db->type;  /* determine database structure type  */
  485.     comp = compare_calls[st];
  486. /* set initial pointers */
  487.     ra = 0L;
  488.     rz = records[st] - 1L;
  489.     db->record = (ra + rz)/2L;  /* go for the middle  */
  490.  
  491.     rec_call = (char *)db->record_buf + call_offset[st];
  492.     ret = 1;
  493.     while (ret != 0)  {
  494.         readrec(db);  /* read in the data pointed to by db->record  */
  495.         for (i=0; i < 50; i++)
  496.             kwait(NULL);  /* sit back and let other processes run for a while.
  497.       The CD-ROM is a slow-access device so lots of other processes may
  498.       be waiting or trying to run - like the keyboard!!! */
  499.  
  500.         reads++;
  501.         ret = comp(callsign, rec_call);
  502.  
  503.         if (ret < 0)  /* callsign < record's callsign field  */
  504.             rz = db->record - 1L;
  505.         else if (ret > 0)  /* callsign > record's callsign field  */
  506.             ra = db->record + 1L;
  507.         else return reads;
  508.  
  509.         if (reads == MAXREADS) return -1;  /* Abnormal return  */
  510.         else if (ra >= rz)  {
  511.             if (met)  return -1;
  512.             else  met = 1;  /* catch this if it happens a second time!  */
  513.         }
  514.         db->record = (ra + rz)/2L;
  515.     }
  516.   /* not reached  */
  517. }
  518. /*---------------- ROUTINES FOR U.S. CALLSIGN DATABASE ----------------------*/
  519.  
  520. /* getdaynum: given a character array 'p' of 'siz' elements, convert the
  521.    array to an ASCIIZ string, return the integer value that it
  522.    represents.
  523.  */
  524. static int
  525. getdaynum(p,siz)
  526. char *p;
  527. int siz;
  528. {
  529.     char *q, tmp[80];
  530.     int ret, i;
  531.  
  532.     q = p;
  533.     for (i = 0; i < siz; i++) {
  534.         tmp[i] = *q++;
  535.     }
  536.     tmp[i] = '\0';
  537.  
  538.     ret = atoi(tmp);
  539.  
  540.     return ret;
  541. }
  542. /* yrval:
  543.    Take the two-letter year code and determine if we have a year that is in
  544.    the 1900's or the 21st century. Return a proper integer answer:
  545.    i.e. "2002" or "1998".
  546.  */
  547. static int
  548. yrval(yrin)
  549. char *yrin;
  550. {
  551.     int i, num;
  552.  
  553.     num = getdaynum(yrin, 2);
  554.  
  555.     if (num > 90) num += 1900;
  556.     else num += 2000;
  557.     return num; /* an integer */
  558. }
  559. /* day_calc: given the 3-element character array 'day' and the 2-element
  560.    character array 'yr', construct a string that returns the date for
  561.    that year, in the form "February 28, 2002" */
  562.  
  563. static char *
  564. day_calc(day, daystr, yr)
  565. char day[3];
  566. char *daystr;
  567. char yr[2];
  568. {
  569.     int i, daynum, subt, year, t;
  570.     char *q, tmp[4];
  571.     int leap = 0;
  572.  
  573.     year = yrval(yr);
  574.  
  575.     if (!(year%4))  leap = 1; /* evenly divisible by four means leap year */
  576.  
  577.     daynum = getdaynum(day, 3);
  578.     if (daynum == 0)  return NULL;
  579.  
  580.  
  581.     subt = 0;
  582.     for (i = 0; i < 12; i++)  {
  583.         if (((t = subt + ((i == 1) ? leap : 0) + month[i].d)) > daynum) break;
  584.         else (subt = t);
  585.     }
  586.     t = daynum - subt;
  587.     if (i == 12)  daystr[0] = '\0';
  588.     else  sprintf(daystr,"%s %d, %d", (t > 0 ? month[i].m : month[--i].m),
  589.         (t > 0 ? t : month[i].d + ((i==1) ? leap : 0)),
  590.         year);
  591.     return daystr;
  592. }
  593. /* comp_usa_calls compares the sought-for callsign with a mask of the
  594.    type encountered in the callsign field of a struct usa,
  595.  
  596.   returns 0 if they match, -1 if mask1 < mask2, 1 if mask1 > mask2.
  597.   mask1 is the callsign requested, mask2 is the database callsign from
  598.   the record under test for match.
  599.  */
  600. static int
  601. comp_usa_calls(mask1, mask2)
  602. char mask1[6];
  603. char mask2[6];
  604. {
  605.     int i;
  606.     char *p, *q;
  607.  
  608.   /* This is in accordance with the way that Buckmaster orders callsigns
  609.      on its CD-ROM database, so follow along:
  610.    */
  611.  
  612.     p = &mask1[2], q = &mask2[2];
  613.     for (i =2; i < 6; i++)  {
  614.         if (*p != *q)  return (int) *p - (int) *q;
  615.         p++, q++;
  616.     }
  617.     p = mask1, q = mask2;
  618.     for (i =0; i < 2; i++)  {
  619.         if (*p != *q)  return (int) *p - (int) *q;
  620.         p++, q++;
  621.     }
  622.     return 0;
  623. }
  624.  
  625. /* for display of an 'X' record in a US callsign record Apr '92 HamCall CD.
  626.   first three elements of the usa struct look like this:
  627.  
  628.        callsign: ∙N8MVI
  629.        lastname: ∙CHANGED∙08/27/91∙∙∙∙∙∙∙
  630.       firstname: ∙SEE∙KF8PH∙
  631.  
  632.       where '∙' is a placeholder to show size only.
  633.       Let's do an appropriate display of this information.
  634.   */
  635.  
  636. static int
  637. display_x(us,s)
  638. struct usa *us;
  639. int s;
  640. {
  641. /*
  642.   in us->lastname, ["∙CHANGED∙08/27/91∙∙∙∙∙∙∙"] us->lastname[17] is where
  643.   to ASCIIZ-ize it. us->callsign is not NULL-terminated, and us->lastname
  644.   follows it immediately. So we will just print out the first two elements
  645.   of the structure usa:
  646.  */
  647.     us->lastname[17] = '\0';
  648. /* A NULL at us->middle will ASCIIZ-ise us->firstname, of which we want
  649.   all past the "SEE".
  650.  */
  651.     us->middle[0] = '\0';
  652.     usprintf(s,"%s\nNew callsign is \"%s\"\n\n", us->callsign, &us->firstname[5]);
  653.     return 0;
  654. }
  655. /*
  656.     Old U.S. callsign display format:
  657.     Buckmaster CD-ROM October 1991
  658.       *** Record #   452100:***
  659. Call:   KB7YW
  660.         FREDERICK A PEACHMAN
  661.         7186 NORTHVIEW DR
  662.         BROOKFIELD , OH 44403
  663. Born:   1954
  664. Class:  EXTRA
  665. Exp:    March 29, 1998
  666.  */
  667. static int
  668. display_usa(us,s)
  669. void *us;
  670. int s;
  671. {
  672.     struct usa *u;
  673.     char daystr[20];
  674.     int yeardate;
  675.     char *Unknown = "%sUnknown Expiration Date\n";
  676.  
  677. /* Sat  05-02-1992  Here I am inserting code to recognize license class 'X',
  678.   which is Buckmaster's way of saying that the license has expired because
  679.   the licensee has changed his callsign - for whatever reason. This is only
  680.   a possibility with the USA database and then only for CD's dated april
  681.   '92 or later. See 'display_x()', above.
  682.     I have commented out my old display format. Gonna simplify it
  683.   somewhat - KB7YW */
  684.  
  685.     u = (struct usa *)us;
  686.  
  687.     if (u->class[0] == 'X')  {
  688.         display_x(us,s);
  689.         return -2;  /* -2 is a flag for the caller to recognize an 'X' record */
  690.     }
  691. /*   usprintf(s, "CALL:   "); */
  692.     disp(u->callsign,sizeof(u->callsign),s);
  693. /*   usprintf(s,"\n%s", TAB); */
  694.     usputc(s,'\n');
  695.     disp(u->firstname,sizeof(u->firstname),s);
  696.     disp(u->middle,sizeof(u->middle),s);
  697.     usputc(s,' ');
  698.     disp(u->lastname,sizeof(u->lastname),s);
  699. /*   usprintf(s,"\n%s", TAB); */
  700.     usputc(s,'\n');
  701.     disp(u->street,sizeof(u->street),s);
  702. /*   usprintf(s,"\n%s", TAB); */
  703.     usputc(s,'\n');
  704.     disp(u->city,sizeof(u->city),s);
  705.     usputs(s,", ");
  706.     disp(u->state,sizeof(u->state),s);
  707.     usputc(s,' ');
  708.     disp(u->zip,sizeof(u->zip),s);
  709.     if (u->born[0] != '-')  {
  710.         usputs(s,"\nBorn 19");
  711.         disp(u->born,sizeof(u->born),s);
  712.     }
  713.     usputs(s,"\nClass:  ");
  714.  
  715.     switch(u->class[0])   {
  716.         case 'N':
  717.             usputs(s,"NOVICE");
  718.             break;
  719.  
  720.         case 'T':
  721.             usputs(s,"TECHNICIAN");
  722.             break;
  723.  
  724.         case 'C':
  725.             usputs(s, "CLUB STATION");
  726.             break;
  727.  
  728.         case 'G':
  729.             usputs(s,"GENERAL");
  730.             break;
  731.  
  732.         case 'A':
  733.             usputs(s,"ADVANCED");
  734.             break;
  735.  
  736.         case 'E':
  737.             usputs(s,"EXTRA");
  738.             break;
  739.  
  740.         default:
  741.             usputc(s,u->class[0]);
  742.     }
  743.     usputc(s,'\n');
  744.  
  745.     yeardate = yrval(u->expiryr);
  746.     if (day_calc(u->expirday, daystr, u->expiryr) != NULL)  {
  747.         if (daystr[0] != '\0')  {
  748.             if ((u->exp[0] == ' ') || (yeardate > 2000))  {
  749.                 usputs(s,"Expires ");
  750.                 usprintf(s,"%s\n", daystr);
  751.             }
  752.             else usprintf(s,Unknown,TAB);
  753.         }
  754.         else usprintf(s,Unknown,TAB);
  755.     }
  756.     return 0;
  757. }
  758.  
  759. /*---------- Procedures specific to Canadian Callsign DataBase----------------*/
  760. static int
  761. display_canada(us,s)
  762. void *us;
  763. int s;
  764. {
  765.     struct canada *u;
  766. #define DISP(x) {usputs(s,"\n        ");\
  767. disp(x, sizeof(x),s);}
  768.  
  769. u = (struct canada *) us;
  770.  
  771. DISP(u->callsign);
  772. DISP(u->name);
  773. DISP(u->street);
  774. DISP(u->town);
  775. disp(u->zip, sizeof(u->zip),s);
  776. usputc(s,'\n');
  777. usprintf(s,"%sCANADA\n",TAB);
  778.  
  779. return 0;
  780. }
  781. /* comp_canada_calls compares the sought-for callsign with a mask of the
  782.    type encountered in the callsign field of a struct canada,
  783.  
  784.   returns 0 if they match, -1 if mask1 < mask2, 1 if mask1 > mask2.
  785.   mask1 is the callsign requested, mask2 is the database callsign from
  786.   the record under test for match.
  787.  */
  788.  
  789. static int
  790. comp_canada_calls(mask1, mask2)
  791. char mask1[6];
  792. char mask2[6];
  793. {
  794.     int i;
  795.     char *p, *q;
  796.  
  797.     p = mask1, q = mask2;
  798.     for (i =0; i < 6; i++)  {
  799.         if (*p != *q)  return (int) *p - (int) *q;
  800.         p++, q++;
  801.     }
  802.     return 0;
  803. }
  804. /* One of three public  functions!  */
  805. int
  806. cb_lookup(s,call)
  807. int s;
  808. char  *call;
  809. {
  810. /* This is the launcher.  Get rid of any callsign validity-checking code
  811.   that happens before calling cb_lookup. Eventually we will have to
  812.   launch the US, Canadian, or foreign Buckmaster CD databases. For right
  813.   now, tho, we only have USA and CANADA.
  814.  
  815.   For April '92 CD we only have USA! - KB7YW
  816.  
  817.     Sat  05-02-1992  Here I am inserting code to recognize license class 'X',
  818.   which is Buckmaster's way of saying that the license has expired because
  819.   the licensee has changed his callsign - for whatever reason. This is only
  820.   a possibility with the USA database and then only for CD's dated april
  821.   '92 or later - KB7YW
  822.  */
  823.     char *q;
  824.     int len, j;
  825.     char mask[7];
  826.     struct database_activity DA;
  827.     char *cant = "Can't handle callsign \"%s\"\n";
  828.     struct ftime ft;
  829.     struct usa *u;
  830.  
  831.                   /* FIRST TEST CALLSIGN FOR VALIDITY */
  832.  
  833.   /* Buckmaster only matches callsigns of 4 to 6 letters in length  */
  834.     len = (call) ? strlen(call) : 0;
  835.     if ((len < 4) || (len > 6)) return invalid_callsign(call,s);
  836.  
  837.     for (j = 0; j < 6; j++) call[j] = toupper(call[j]);
  838.  
  839.                   /* every character must be alphanumeric */
  840.     q = call;
  841.     for (j = 0; j < len; j++) if (!(isalnum(*q++)))
  842.             return invalid_callsign(call,s);
  843.  
  844.     q = call;
  845.         switch (*q) {
  846.             case 'A':
  847.             case 'K':
  848.             case 'N':
  849.             case 'W':
  850.                 if ((init(&DA, USA, s)) == -1)  return 0;
  851.                 if ((make_mask(mask, call, s)) == -1) {
  852.                     close_down(&DA);
  853.                     return 0;
  854.                 }
  855.                 break;
  856.  
  857.             case 'V':
  858.                 if ((strncmp(call,"VO",2) == 0) || (strncmp(call,"VE",2) == 0)) {
  859.                     if ((init(&DA, CANADA, s)) == -1)  return 0;
  860.                     if ((make_mask(mask, call, s)) == -1)   {
  861.                         close_down(&DA);
  862.                         return 0;
  863.                     }
  864.                 }
  865.                 else  {
  866.                     usprintf(s,cant,call);
  867.                     return 0;
  868.                 }
  869.                 break;
  870.  
  871.             default:
  872.                 usprintf(s,cant,call);
  873.                 return 0;
  874.         }
  875.  
  876.     if ((find_call(&DA,mask)) == -1)
  877.         usprintf(s, "\n\nCallsign \"%s\" not found\n\n",call);
  878.     else {
  879.         while (displayrec(&DA,s) == -2)  {
  880. /* If we got to here, we are dealing with an 'X' record, which is only a
  881.   possibility in the USA database. (Of course now (Sat  05-02-1992), we
  882.   only have the U.S. database to play with as of April '92 HamCall CD).
  883.   Soon we can get rid of the Canadian stuff, since the CD's that support
  884.   it will be too old to use.
  885.  */
  886.             u = (struct usa *) DA.record_buf;
  887.  
  888. /* Buckmaster will have filled out u->firstname as: "∙SEE∙KF8PH∙". So
  889.    our new callsign to look up is at position 5 in u->firstname!
  890.  */
  891.             strncpy(call, &u->firstname[5], 6);/* put in the new callsign !!! */
  892.             if ((make_mask(mask, call, s)) == -1)   {
  893.                 close_down(&DA);
  894.                 return 0;
  895.             }
  896.             if ((find_call(&DA,mask)) == -1)  {
  897.                 usprintf(s, "\n\nCallsign \"%s\" not found\n\n",call);
  898.                 break;  /* Get out of what might otherwise be an infinite loop  */
  899.             }
  900.         }
  901.         getftime(DA.handle, &ft);
  902.         usprintf(s,"\nDatabase date: %s %d, %02d\n\n\n",
  903.         month[ft.ft_month-1].m, ft.ft_day, ft.ft_year+1980);
  904.     }
  905.     /* find_call returns with appropriate record already read into
  906.        DA.record_buf and the return value is -1 for error or number of
  907.        seeks required on success.
  908.      */
  909.  
  910.     close_down(&DA);
  911.     return 0;
  912. }
  913.  
  914. #else   /* #ifndef ICALL  i.e. ICALL is now defined, & here's what you get: */
  915.  
  916. /* Buckmaster's international callsign database - new April '92             */
  917. long Mincoreleft = 77000L;      /* minimum coreleft needed for icall.exe    */
  918. int init_Database(char *);      /* public - used by cdbstart in callcdb.c   */
  919. static int get_Database_date(char *);
  920. char *Database_date = NULLCHAR; /* set once in get_Database_date()          */
  921. char *Database = NULLCHAR;      /* set by init_Database()                   */
  922. char *db = "/ham0/hamcall.all"; /* default initialized address for Database */
  923.  
  924. int
  925. cb_lookup(s,call)
  926. int s;
  927. char  *call;
  928. {
  929.     FILE *fp, *fd;
  930.     char command[50];
  931.     char file[20], dosfile[20];
  932.     int fhandle, retval;
  933.     long filesize;
  934.     char *q, *p;
  935.  
  936.     if (coreleft() < Mincoreleft) {
  937.         usprintf(s,
  938.         "\n\n\tLow System Memory !!!.\n\
  939.         \tAlert sysop @ %s:\n\
  940.         \tCannot service callsign -\n\
  941.         \tdatabase requests until\n\
  942.         \tprogram reboots.\n\n", Callserver);
  943.         log(s,"callserver failure [insufficient memory]");
  944.         return 0;
  945.     }
  946.  
  947.     if (Database == NULLCHAR)
  948.         init_Database(NULLCHAR);
  949.  
  950.     tmpnam(file);
  951.     strncpy(dosfile, file, 20);
  952.     q = dosfile;
  953.  
  954.     while (*q != '\0')  {
  955.         if (*q == '/') *q = '\\'; /* make slashes into backslashes for MS-DOS */
  956.         q++;
  957.     }
  958.  
  959.     sprintf(command,"%s\\icall.exe %s %s *> %s",CDROM, CDROM, call, dosfile);
  960.  
  961.     retval = system(command);
  962.  
  963.     if (!retval)  {
  964.         if((fp = fopen(file,READ_TEXT)) != NULLFILE) {
  965.             sendfile(fp,s,ASCII_TYPE,0,NULL);
  966.             if (Database_date != NULLCHAR)
  967.                 usprintf(s, "\n\nDatabase date: %s\n\n\n", Database_date);
  968.             fclose(fp);
  969.             remove(file);
  970.             return 0;
  971.         }
  972.     }
  973.     usputs(s,"Could not open database - please try later\n\n");
  974.     return 0;
  975. }
  976. #endif  /* #ifndef ICALL */
  977. #endif /* #ifdef CALLSERVER */
  978.  
  979. struct cmds Callserver_cmds[] = {
  980.     { "hostname",    docallserver_hostname,    0, 0, NULLCHAR },
  981. #ifdef CALLSERVER /* not used if only CALLCLI is defined  */
  982.     { "database",    docallserver_databases,    0, 0, NULLCHAR },
  983. #endif
  984.     { NULLCHAR,    NULL,            0, 0, NULLCHAR }    
  985. };
  986.  
  987. /* Another public, headered in commands.h */
  988. int
  989. docallserver(argc,argv,p)
  990. int argc;
  991. char *argv[];
  992. void *p;
  993. {
  994.     return subcmd(Callserver_cmds, argc, argv, p);
  995. }
  996.  
  997. static int
  998. docallserver_hostname(argc,argv,p)
  999. int argc;
  1000. char *argv[];
  1001. void *p OPTIONAL;
  1002. {
  1003.     if(argc < 2)
  1004.     {
  1005.         if(Callserver != NULLCHAR)
  1006.             tprintf("The callserver's hostname is: %s\n",Callserver);
  1007.         else
  1008.         {
  1009.             tputs("Callserver not configured!\n");
  1010.             tputs("Usage: callserver hostname <hostname>|<ip_address>\n");
  1011.         }
  1012.     }
  1013.     else {
  1014.         if(Callserver != NULLCHAR)
  1015.             free(Callserver);
  1016.         Callserver = strdup(argv[1]);
  1017.     }
  1018.     return 0;
  1019. }
  1020. #ifdef CALLSERVER
  1021. #ifdef ICALL
  1022.  
  1023. /* For the new (May '92) HamCall CD the  callserver database is
  1024. "/ham0/hamcall.all" unless the user specifies otherwise
  1025.  */
  1026.  
  1027. static int
  1028. get_Database_date(db)
  1029. char *db; /* temporary string contains putative database filename  */
  1030. {
  1031.     FILE *fd;
  1032.     int fhandle;
  1033.     struct ftime ft;
  1034.     char tmpstr[50];
  1035.     char database[50];
  1036.  
  1037. /*  CDROM contains drive letter + ':', e.g. "s:"
  1038.     db contains the rest of the path + database file name, e.g.
  1039.     "/ham0/hamcall.exe".
  1040.  */
  1041.     sprintf(database, "%s%s", CDROM, db);
  1042.  
  1043.     if ((fd = fopen(database, "rb")) != NULLFILE) {
  1044.         fhandle = fileno(fd);
  1045.         getftime(fhandle, &ft);
  1046.         sprintf(tmpstr,"%s %d, %02d",
  1047.         month[ft.ft_month-1].m, ft.ft_day, ft.ft_year+1980);
  1048.         fclose(fd);
  1049.         if (Database_date != NULLCHAR) free(Database_date);
  1050.         Database_date = strdup(tmpstr); /* Now it's initialized!! */
  1051.         return 0;
  1052.     }
  1053.     else return -1;   /* Database could not be opened for binary read */
  1054. }
  1055.  
  1056. /* public: called when the ICALL callserver is started. db must be allocated
  1057.     with strdup unless it is to be assigned to the global char *db,
  1058.     declared this module. In which case db should be passed as NULLCHAR.
  1059.  */
  1060.  
  1061. int
  1062. init_Database(tmp_db)
  1063. char *tmp_db;
  1064. {
  1065.     extern char *db;  /* global: "/ham0/hamcall.all"  */
  1066.  
  1067.     if (tmp_db == NULLCHAR) tmp_db = db;
  1068.  
  1069.     if (Database == NULLCHAR)
  1070.         if (CDROM == NULLCHAR)  {
  1071.             tputs(cdrom_prompt);
  1072.             return -1;
  1073.         }
  1074.     if (get_Database_date(tmp_db) == 0) {
  1075.         Database = tmp_db;
  1076.         return 0;
  1077.     } else  {
  1078.         tprintf(
  1079.         "\t%c%s could not be found.\n\
  1080.         \tPlace \"Ham Call\" CD in CD-ROM drive \"%s\" -OR\n",'\007',tmp_db, CDROM);
  1081.         tputs(
  1082.         "\tspecify alternate callserver database filename.\n");
  1083.         return -1;
  1084.     }
  1085. }
  1086.  
  1087. static int
  1088. docallserver_databases(argc,argv,p)
  1089. int argc;
  1090. char *argv[];
  1091. void *p;
  1092. {
  1093.     char *tmpstr;
  1094.     char *cs = "callserver database";
  1095.  
  1096.     if (argc == 1 ) {
  1097.         tprintf("%s ", cs);
  1098.         if (Database == NULLCHAR) {
  1099.             tputs("not configured.\n"); /* Will not be configured unless
  1100.                                          user has already used the "cdrom"
  1101.                                          command, and optionally
  1102.                                          "callserver database </path/filename>"
  1103.                                          as well as "start callbook".
  1104.                                        */
  1105.             if (CDROM == NULLCHAR)
  1106.                 tputs(cdrom_prompt);
  1107.         }
  1108.         else  tprintf("is \"%s\" (dated %s)\n", Database, Database_date);
  1109.         return 0;
  1110.     } else if (argc >= 2)   {
  1111.         tmpstr = strdup(argv[1]);
  1112.         if (init_Database(tmpstr) == 0) {
  1113.             return 0;
  1114.         } else  {
  1115.             free(tmpstr);
  1116.       /* no error reporting. init_Database() does plenty of that  */
  1117.             return -1;
  1118.         }
  1119.     }
  1120.     return 0;
  1121. }
  1122.  
  1123.  
  1124. #else       /* #ifdef ICALL i.e. ICALL is NOT defined here. You use this
  1125.                 with the old-style database  */
  1126. static int
  1127. docallserver_databases(argc,argv,p)
  1128. int argc;
  1129. char *argv[];
  1130. void *p;
  1131. {
  1132.     int t;
  1133.  
  1134.     if (argc < 2) {
  1135.         for (t = 0; t < DATABASE_TYPES; t++)  {
  1136.             tprintf("callserver database %s ", database_label[t]);
  1137.             if (database[t] == NULLCHAR)  {
  1138.                 tputs("not configured.\n");
  1139.             } else  tprintf("%s\n", database[t]);
  1140.         }
  1141.         return 0;
  1142.     } else  { /* argc >= 2 */
  1143.         for (t = 0; t < DATABASE_TYPES; t++)  {
  1144.             if (strncmp(database_label[t],argv[1],strlen(argv[1])) == 0)  {
  1145.                 if (argc < 3) {
  1146.                     tprintf("callserver database %s ", database_label[t]);
  1147.                     if (database[t] == NULLCHAR)  tputs("not configured\n");
  1148.                     else  tprintf("%s\n", database[t]);
  1149.                 } else  { /* argc >= 3  */
  1150.                     if (database[t] == NULLCHAR)  free(database[t]);
  1151.                     database[t] = strdup(argv[2]);
  1152.                 }
  1153.                 return 0; /* we have found our match with database_label[t] */
  1154.             }
  1155.         }
  1156.       /* no match with database_label: which database?  */
  1157.         tputs("Usage: callserver database ");
  1158.         for (t = 0; t < DATABASE_TYPES; t++)  {
  1159.             tprintf("%s", database_label[t]);
  1160.             if ( t < DATABASE_TYPES - 1)  tputc('|');
  1161.         }
  1162.         tputs(" <database drive:/path/filename>\n");
  1163.         return -1;
  1164.     }
  1165.   /* not reached  */
  1166. }
  1167. #endif  /* #ifdef ICALL  */
  1168.  
  1169. /* the last public of this module, also headered in commands.h  */
  1170. int
  1171. docdrom(argc,argv,p)
  1172. int argc;
  1173. char *argv[];
  1174. void *p;
  1175. {
  1176.     extern char *CDROM; /* declared above, this module  */
  1177.  
  1178.     if (argc < 2) {
  1179.         if (CDROM == NULLCHAR)  {
  1180.             tputs("CDROM drive letter not specified\n");
  1181.         }
  1182.         else  tprintf("CDROM drive is \"%s\"\n", CDROM);
  1183.         return 0;
  1184.     }
  1185.     else  {
  1186.         if ((argv[1][2] == '\0')    &&
  1187.             (isalpha(argv[1][0]))   &&
  1188.         (argv[1][1] == ':'))  {
  1189.             if (CDROM != NULLCHAR)  free(CDROM);
  1190.             CDROM = strdup(argv[1]);
  1191.             return 0;
  1192.         }
  1193.         else  {
  1194.             tputs("Usage: \"cdrom driveletter:\", e.g. \"cdrom s:\"\n");
  1195.             return 1;
  1196.         }
  1197.     }
  1198.   /* not reached  */
  1199. }
  1200. #endif  /* #ifdef CALLSERVER  */
  1201. #endif /* BUCKBOOK */
  1202. #endif /* QRZCALLB */
  1203. #endif /* MSDOS */
  1204.  
  1205.